package com.example.managemyself.data.repository;

import android.app.Application;
import androidx.lifecycle.LiveData;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

import com.example.managemyself.data.database.AppDatabase;
import com.example.managemyself.data.database.TaskDao;
import com.example.managemyself.data.model.Task;

/**
 * 任务仓库类，作为数据访问层和ViewModel之间的中介
 */
public class TaskRepository implements ITaskRepository {
    
    private final TaskDao taskDao;
    private final LiveData<List<Task>> allTasks;
    private final ExecutorService executorService;
    
    public TaskRepository(Application application) {
        AppDatabase database = AppDatabase.getInstance(application);
        taskDao = database.taskDao();
        allTasks = taskDao.getAllTasks();
        executorService = Executors.newSingleThreadExecutor();
    }
    
    // 获取所有任务
    @Override
    public LiveData<List<Task>> getAllTasks() {
        return allTasks;
    }
    
    // 根据ID获取任务
    @Override
    public LiveData<Task> getTaskById(int id) {
        return taskDao.getTaskById(id);
    }
    
    // 根据状态获取任务
    @Override
    public LiveData<List<Task>> getTasksByStatus(String status) {
        return taskDao.getTasksByStatus(status);
    }
    
    // 根据类型获取任务
    @Override
    public LiveData<List<Task>> getTasksByType(String type) {
        return taskDao.getTasksByType(type);
    }
    
    // 根据重要程度获取任务
    @Override
    public LiveData<List<Task>> getTasksByImportance(int importance) {
        return taskDao.getTasksByImportance(importance);
    }
    
    // 根据紧急程度获取任务
    @Override
    public LiveData<List<Task>> getTasksByUrgency(String urgency) {
        return taskDao.getTasksByUrgency(urgency);
    }
    
    // 插入任务
    @Override
    public void insertTask(Task task) {
        executorService.execute(() -> taskDao.insertTask(task));
    }
    
    // 更新任务
    @Override
    public void updateTask(Task task) {
        executorService.execute(() -> taskDao.updateTask(task));
    }
    
    // 删除任务
    @Override
    public void deleteTask(Task task) {
        executorService.execute(() -> taskDao.deleteTask(task));
    }
    
    // 根据ID删除任务
    @Override
    public void deleteTaskById(int id) {
        executorService.execute(() -> taskDao.deleteTaskById(id));
    }

    public void insert(Task task) {
        executorService.execute(() -> taskDao.insert(task));
    }

    public void update(Task task) {
        executorService.execute(() -> taskDao.update(task));
    }

    public void delete(Task task) {
        executorService.execute(() -> taskDao.delete(task));
    }

    public void deleteTasksByIds(List<Integer> taskIds) {
        executorService.execute(() -> taskDao.deleteTasksByIds(taskIds));
    }
    
    // 根据标签获取任务（暂时返回空列表，因为Task模型中没有tag字段）
    @Override
    public LiveData<List<Task>> getTasksByTag(String tag) {
        // TODO: 实现标签功能
        return taskDao.getAllTasks(); // 临时返回所有任务
    }
    
    // 根据优先级获取任务（使用urgency字段）
    @Override
    public LiveData<List<Task>> getTasksByPriority(String priority) {
        return taskDao.getTasksByUrgency(priority);
    }
    
    // 同步方法供AIDataManager使用
    public List<Task> getAllTasksSync() {
        try {
            return taskDao.getAllTasksSync();
        } catch (Exception e) {
            return new java.util.ArrayList<>();
        }
    }
    
    public List<Task> getCompletedTasksSync() {
        try {
            return taskDao.getTasksByStatusSync("已完成");
        } catch (Exception e) {
            return new java.util.ArrayList<>();
        }
    }
    
    public List<Task> getPendingTasksSync() {
        try {
            return taskDao.getTasksByStatusSync("待完成");
        } catch (Exception e) {
            return new java.util.ArrayList<>();
        }
    }
    
    // LiveData版本的方法
    public LiveData<List<Task>> getPendingTasks() {
        return taskDao.getTasksByStatus("待完成");
    }
    
    public LiveData<List<Task>> getCompletedTasks() {
        return taskDao.getTasksByStatus("已完成");
    }
    
    // 获取指定日期完成的任务（同步方法）
    @Override
    public List<Task> getCompletedTasksByDateSync(java.util.Date date) {
        try {
            return taskDao.getCompletedTasksByDateSync(date);
        } catch (Exception e) {
            return new java.util.ArrayList<>();
        }
    }
    
    // 获取指定日期完成的任务（异步方法）
    @Override
    public LiveData<List<Task>> getCompletedTasksByDate(String dateStr) {
        return taskDao.getCompletedTasksByDate(dateStr);
    }
}
